feat(agents): Cap'n Web connection transport on the WebSockets capability - #2156

Lifecycle no longer models WebSockets — many hosts never use sockets,
and connection behavior was never really lifecycle's concern. Hosts
that want connections install the WebSockets capability, which owns
the subsystem end to end:

  new WebSockets({
    handlers: { onConnect, onMessage, onClose },
    callables: new RoomCallables()
  })

The capability claims upgrades, accepts hibernating sockets (the
connection layer moved wholesale from lifecycle/connection.ts —
attachment format unchanged, so live hibernated connections survive
the migration), dispatches handlers inside the host invocation
boundary with the live connection in ambient context, reciprocates
close handshakes, closes owned connections on host destruction, and
answers getConnections()/getConnection(). Without it installed,
upgrades are declined.

Callables: pass an RpcTarget and its prototype methods are the remote
interface, served over a Cap'n Web session (?__agents_rpc=capnweb)
with native ReadableStream streaming, host-boundary dispatch, and
rpc/rpc:error events; agents/websockets/client ships a typed
CallablesClient. On an Agent, override the callables() template
method to supply the target (preferred); @callable()-decorated
methods remain the fallback interface, and the resolved interface is
served on every wire — the legacy JSON RPC protocol dispatches
explicit-target methods too, streaming ReadableStream results as
legacy chunk frames. The decorator machinery moved to
callable-decorator.ts so both consumers share one registry.

Agent migrates onto the capability in this change: it installs a
WebSockets instance whose handlers call through Agent's wrapped
hooks, and its connection reads go through the capability. Agent's
public API and wire protocol are unchanged — the full Agent suite
passes as-is. The think packages ride Agent's public API and need no
changes.

Lifecycle keeps only generic platform pass-throughs —
onWebSocketUpgrade to claim upgrades, onWebSocketMessage/Close/Error
to consume hibernation wakes for capability-owned sockets — and
LifecycleServices gains a narrow sockets surface (accept/get, not the
whole DurableObjectState) plus a connection/request scope on
runInHostContext, which Agent's host invoker threads into its
invocation context. The capability interaction contract — hooks,
services, and composition-root apertures as the only three channels,
with the claim/consume dispatch rules — is documented on
DurableObjectCapability.

PlainLifecycleObject and the examples/next/lifecycle example run on
the capability (handlers + callables), so the pre-existing Lifecycle
WebSocket, host-context, and hibernation suites prove handler parity.
New suites cover the callables endpoint on both wires: receiver
binding, host boundary, rpc events, streaming, merged interface
(explicit target preferred, decorators fallback), decorator-only
agents, and legacy-wire dispatch of target methods.

…web re-applied next)